import { commonRegex } from "./regex-patterns";
export { commonRegex }
/**
 * 字符串非空校验（含空字符串和全空格判断）
 * @param str 待校验字符串
 * @returns 是否非空
 */
export function isNonEmpty(str: string | undefined | null): boolean {
  return !!str && str.trim().length > 0;
}

/**
 * 基础正则校验
 * @param str 待校验字符串
 * @param pattern 正则模式（支持预定义类型或自定义正则）
 * @returns 是否匹配
 */
export function regexValidate(
  str: string,
  pattern: keyof typeof commonRegex | RegExp
): boolean {
  const regex = pattern instanceof RegExp ? pattern : commonRegex[pattern];
  return regex.test(str);
}

/**
 * 生成随机验证码
 * @param length 验证码长度（4或6，默认4）
 * @returns 随机验证码字符串
 */
export function generateVerifyCode(length: 4 | 6 = 4): string {
  const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  return Array.from({ length }, () =>
    chars[Math.floor(Math.random() * chars.length)]
  ).join('');
}

/**
 * 通用深拷贝（支持循环引用）
 * @param source 待拷贝对象
 * @returns 深拷贝后的新对象
 */
export function deepClone<T>(source: T): T {
  const cache = new WeakMap();
  function clone(value: unknown): unknown {
    // 处理原始类型和 null/undefined
    if (value === null || typeof value !== 'object') return value;
    // 处理特殊对象类型
    if (value instanceof Date) return new Date(value);
    if (value instanceof RegExp) return new RegExp(value);
    if (value instanceof Set) return new Set([...value]);
    if (value instanceof Map) return new Map([...value]);

    // 处理循环引用
    if (cache.has(value)) return cache.get(value);

    // 处理普通对象/数组
    const target = Array.isArray(value) ? [] : {};
    cache.set(value, target);

    for (const key in value) {
      if (Object.prototype.hasOwnProperty.call(value, key)) {
        (target as Record<string, unknown>)[key] = clone(value[key as keyof typeof value]);
      }
    }
    return target;
  }

  return clone(source) as T;
}

/**
 * 通用防抖函数
 * @param fn 目标函数
 * @param wait 防抖时间（ms）
 * @param immediate 是否立即执行（默认false）
 * @returns 防抖包装函数
 */
export function debounce<T extends (...args: any[]) => any>(
  fn: T,
  wait: number = 300,
  immediate: boolean = false
): (...args: Parameters<T>) => void {
  let timer: ReturnType<typeof setTimeout> | null = null;

  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
    const context = this;
    if (timer) clearTimeout(timer);
    if (immediate) {
      const callNow = !timer;
      timer = setTimeout(() => { timer = null; }, wait);
      if (callNow) fn.apply(context, args);
    } else {
      timer = setTimeout(() => {
        fn.apply(context, args);
      }, wait);
    }
  };
}

/**
 * 通用节流函数（时间戳实现）
 * @param fn 目标函数
 * @param wait 节流时间（ms）
 * @returns 节流包装函数
 */
export function throttle<T extends (...args: any[]) => any>(
  fn: T,
  wait: number = 300
): (...args: Parameters<T>) => void {
  let previous = 0;
  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
    const now = Date.now();
    const context = this;
    if (now - previous > wait) {
      fn.apply(context, args);
      previous = now;
    }
  };
}